// Go作者版权所有。版权所有。
// 此源代码的使用受BSD样式的约束
// 可以在许可证文件中找到的许可证。

package ssa

import "cmd/compile/internal/types"

// zcse在上执行公共子表达式消除的初始过程
// 函数用于具有零参数的值，以允许更昂贵的cse
// 从减少值的数量开始。值只是重新链接，
// 没有删除任何内容。需要后续的死码传递才能实际执行
// 删除重复的表达式。
func zcse(f *Func) {
	vals := make(map[vkey]*Value)

	for _, b := range f.Blocks {
		for i := 0; i < len(b.Values); i++ {
			v := b.Values[i]
			if opcodeTable[v.Op].argLen == 0 {
				key := vkey{v.Op, keyFor(v), v.Aux, v.Type}
				if vals[key] == nil {
					vals[key] = v
					if b != f.Entry {
						// 将v移动到入口块，使其控制每个块
						// 我们可能使用它的地方。这就不需要任何支配者
						// 这一关的计算。
						v.Block = f.Entry
						f.Entry.Values = append(f.Entry.Values, v)
						last := len(b.Values) - 1
						b.Values[i] = b.Values[last]
						b.Values[last] = nil
						b.Values = b.Values[:last]

						i-- // 再次处理b.值[i]
					}
				}
			}
		}
	}

	for _, b := range f.Blocks {
		for _, v := range b.Values {
			for i, a := range v.Args {
				if opcodeTable[a.Op].argLen == 0 {
					key := vkey{a.Op, keyFor(a), a.Aux, a.Type}
					if rv, ok := vals[key]; ok {
						v.SetArg(i, rv)
					}
				}
			}
		}
	}
}

// vkey是用于唯一标识零arg值的类型。
type vkey struct {
	op Op
	ai int64       // 辅助整数
	ax Aux         // 辅助的
	t  *types.Type // 类型
}

// keyFor返回唯一标识
// 支持的ops的参数值为零。
func keyFor(v *Value) int64 {
	switch v.Op {
	case OpConst64, OpConst64F, OpConst32F:
		return v.AuxInt
	case OpConst32:
		return int64(int32(v.AuxInt))
	case OpConst16:
		return int64(int16(v.AuxInt))
	case OpConst8, OpConstBool:
		return int64(int8(v.AuxInt))
	default:
		return v.AuxInt
	}
}
